// 第一种：请求防抖，后续请求直接拦截不触发
let myRequest = (function () {
    let hasRequest = []
    return function (config) {
        if (hasRequest.includes(config.url)) {
            return Promise.reject({message: '请求已经提交'})
        }
        hasRequest.push(config.url)
        return request(...config).then(res => {
            hasRequest = hasRequest.map(item => item !== config.url)
        })
    }
})()

// 第二种：请求防抖+后续的重复请求值返回第一次的结果

// 缓存对象
const requestCache = {};

// 生成唯一的缓存键
function generateCacheKey(config) {
    const params = config.params ? JSON.stringify(config.params) : '';
    return `${config.url}|${params}`;
}

// 二次封装的请求方法
async function myRequest(config) {
    const cacheKey = generateCacheKey(config);

    // 检查缓存中是否有未过期的请求
    if (requestCache[cacheKey]) {
        const {response, timestamp} = requestCache[cacheKey];
        const now = Date.now()
        // 如果在 1 秒内重复请求，直接返回缓存的响应
        if (now - timestamp < 1000) {
            console.log('重复请求，直接返回缓存结果');
            return response;
        }

        // 清理过期的缓存
        delete requestCache[cacheKey];
    }

    // 创建新的请求并缓存 instance是axios的实例
    const responsePromise = instance(config);
    requestCache[cacheKey] = {
        response: responsePromise,
        timestamp: Date.now(),
    };

    try {
        const response = await responsePromise;
        return response;
    } finally {
        // 请求完成后清理缓存
        delete requestCache[cacheKey];
    }
}

export default myRequest;